package com.example.demo.scheduling;

import com.example.demo.mysqlDao.MysDao;
import com.example.demo.mysqlDao.PersonnelDao;
import com.example.demo.service.OraService;
import com.example.demo.util.R;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.thymeleaf.util.StringUtils;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;

@Configuration // 主要用于标记配置类，兼备Component的效果
@EnableScheduling // 开启定时任务
public class DynamicScheduleTask implements SchedulingConfigurer {

    private static final Logger LOG = LoggerFactory.getLogger(SchedulingConfigurer.class);

    @Resource
    private MysDao mysDao;

    @Resource
    private OraService oraService;

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {

        //表1
        taskRegistrar.addTriggerTask(() ->
                        // 任务内容（Runnable）

//                        System.out.println("执行动态定时任务1: " + LocalDateTime.now().toLocalTime()),
//                        System.out.println(),
                oraService.OraAlarmitems(),
                // 设置执行周期（Trigger）
                triggerContext -> {
                    // 从数据库获取Cron表达式参数
                    Map params = new HashMap();
                    params.put("cronId", 1);
                    Map<String, Object> data = mysDao.selectCron(params);
                    if (null == data){
                        return null;
                    }
                    String cron = String.valueOf(data.get("cron"));
//                    String cron = "0/5 * * * * ?";

                    // 校验，或者也可以添加其它校验。只要查出的能满足Cron表达式规则就行
                    if (StringUtils.isEmpty(cron)) {
                        cron = "0,59 59 23 * * ?";
                    }
                    //返回执行周期（Date）
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                }
        );

        //表2
        taskRegistrar.addTriggerTask(() ->
                        // 任务内容（Runnable）

//                        System.out.println("执行动态定时任务1: " + LocalDateTime.now().toLocalTime()),
                oraService.OraBasicinfo(),
                // 设置执行周期（Trigger）
                triggerContext -> {
                    // 从数据库获取Cron表达式参数
                    Map params = new HashMap();
                    params.put("cronId", 1);
                    Map<String, Object> data = mysDao.selectCron(params);
                    if (null == data){
                        return null;
                    }
                    String cron = String.valueOf(data.get("cron"));
//                    String cron = "0/5 * * * * ?";

                    // 校验，或者也可以添加其它校验。只要查出的能满足Cron表达式规则就行
                    if (StringUtils.isEmpty(cron)) {
                        cron = "0,59 59 23 * * ?";
                    }
                    //返回执行周期（Date）
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                }
        );

        //表3
        taskRegistrar.addTriggerTask(() ->
                        // 任务内容（Runnable）

//                        System.out.println("执行动态定时任务1: " + LocalDateTime.now().toLocalTime()),
                        oraService.OraCheckcar(),
                // 设置执行周期（Trigger）
                triggerContext -> {
                    // 从数据库获取Cron表达式参数
                    Map params = new HashMap();
                    params.put("cronId", 1);
                    Map<String, Object> data = mysDao.selectCron(params);
                    if (null == data){
                        return null;
                    }
                    String cron = String.valueOf(data.get("cron"));
//                    String cron = "0/5 * * * * ?";

                    // 校验，或者也可以添加其它校验。只要查出的能满足Cron表达式规则就行
                    if (StringUtils.isEmpty(cron)) {
                        cron = "0,59 59 23 * * ?";
                    }
                    //返回执行周期（Date）
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                }
        );

        //表4
        taskRegistrar.addTriggerTask(() ->
                        // 任务内容（Runnable）

//                        System.out.println("执行动态定时任务1: " + LocalDateTime.now().toLocalTime()),
                        oraService.OraChecksize(),
                // 设置执行周期（Trigger）
                triggerContext -> {
                    // 从数据库获取Cron表达式参数
                    Map params = new HashMap();
                    params.put("cronId", 1);
                    Map<String, Object> data = mysDao.selectCron(params);
                    if (null == data){
                        return null;
                    }
                    String cron = String.valueOf(data.get("cron"));
//                    String cron = "0/5 * * * * ?";

                    // 校验，或者也可以添加其它校验。只要查出的能满足Cron表达式规则就行
                    if (StringUtils.isEmpty(cron)) {
                        cron = "0,59 59 23 * * ?";
                    }
                    //返回执行周期（Date）
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                }
        );

        //表5
        taskRegistrar.addTriggerTask(() ->
                        // 任务内容（Runnable）

//                        System.out.println("执行动态定时任务1: " + LocalDateTime.now().toLocalTime()),
                        oraService.OraCheckwheelscar(),
                // 设置执行周期（Trigger）
                triggerContext -> {
                    // 从数据库获取Cron表达式参数
                    Map params = new HashMap();
                    params.put("cronId", 1);
                    Map<String, Object> data = mysDao.selectCron(params);
                    if (null == data){
                        return null;
                    }
                    String cron = String.valueOf(data.get("cron"));
//                    String cron = "0/5 * * * * ?";

                    // 校验，或者也可以添加其它校验。只要查出的能满足Cron表达式规则就行
                    if (StringUtils.isEmpty(cron)) {
                        cron = "0,59 59 23 * * ?";
                    }
                    //返回执行周期（Date）
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                }
        );

        //表6
        taskRegistrar.addTriggerTask(() ->
                        // 任务内容（Runnable）

//                        System.out.println("执行动态定时任务1: " + LocalDateTime.now().toLocalTime()),
                        oraService.OraOverdemarcationrecord(),
                // 设置执行周期（Trigger）
                triggerContext -> {
                    // 从数据库获取Cron表达式参数
                    Map params = new HashMap();
                    params.put("cronId", 1);
                    Map<String, Object> data = mysDao.selectCron(params);
                    if (null == data){
                        return null;
                    }
                    String cron = String.valueOf(data.get("cron"));
//                    String cron = "0/5 * * * * ?";

                    // 校验，或者也可以添加其它校验。只要查出的能满足Cron表达式规则就行
                    if (StringUtils.isEmpty(cron)) {
                        cron = "0,59 59 23 * * ?";
                    }
                    //返回执行周期（Date）
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                }
        );

        //表7
        taskRegistrar.addTriggerTask(() ->
                        // 任务内容（Runnable）

//                        System.out.println("执行动态定时任务1: " + LocalDateTime.now().toLocalTime()),
                        oraService.OraJczb(),
                // 设置执行周期（Trigger）
                triggerContext -> {
                    // 从数据库获取Cron表达式参数
                    Map params = new HashMap();
                    params.put("cronId", 1);
                    Map<String, Object> data = mysDao.selectCron(params);
                    if (null == data){
                        return null;
                    }
                    String cron = String.valueOf(data.get("cron"));
//                    String cron = "0/5 * * * * ?";

                    // 校验，或者也可以添加其它校验。只要查出的能满足Cron表达式规则就行
                    if (StringUtils.isEmpty(cron)) {
                        cron = "0,59 59 23 * * ?";
                    }
                    //返回执行周期（Date）
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                }
        );



        //全量每周一次的
        taskRegistrar.addTriggerTask(() ->
                        // 任务内容（Runnable）

//                        System.out.println("执行动态定时任务1: " + LocalDateTime.now().toLocalTime()),
//                        oraService
                        allImport(),
                // 设置执行周期（Trigger）
                triggerContext -> {
                    // 从数据库获取Cron表达式参数
                    Map params = new HashMap();
                    params.put("cronId", 2);
                    Map<String, Object> data = mysDao.selectCron(params);
                    if (null == data){
                        return null;
                    }
                    String cron = String.valueOf(data.get("cron"));
//                    String cron = "0/5 * * * * ?";

                    // 校验，或者也可以添加其它校验。只要查出的能满足Cron表达式规则就行
                    if (StringUtils.isEmpty(cron)) {
                        cron = "0,59 59 23 * * ?";
                    }
                    //返回执行周期（Date）
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                }
        );
    }


   public void allImport(){

           try{
               //表1
               oraService.OraAlarmitemsPage();System.out.println("1导入成功-----");
               //表2
               oraService.OraBasicinfoPage();System.out.println("2导入成功-----");
               //表3
               oraService.OraCheckcarPage();System.out.println("3导入成功-----");
               //表4
               oraService.OraChecksizePage();System.out.println("4导入成功-----");
               //表5
               oraService.OraCheckwheelscarPage();System.out.println("5导入成功-----");
               //表6
               oraService.OraOverdemarcationrecordPage();System.out.println("6导入成功-----");
               //表7
               oraService.OraJczbPage();System.out.println("7导入成功-----");

           }catch (Exception e){
               System.out.println(e.getMessage());
               LOG.error("错误", e.getMessage());
           }
    }
}